TypeScript போக்குவரத்து மேம்படுத்தல்: இயக்கம் வகை செயல்படுத்தலுக்கான ஒரு உலகளாவிய வழிகாட்டி

நவீன வர்த்தகம் மற்றும் நகர்ப்புற வாழ்க்கையின் பரபரப்பான, ஒன்றுக்கொன்று இணைக்கப்பட்ட உலகில், மக்கள் மற்றும் பொருட்களின் திறமையான இயக்கம் மிக முக்கியமானது. அடர்த்தியான நகர நிலப்பரப்புகளை வழிநடத்தும் கடைசி-மைல் டெலிவரி டிரோன்கள் முதல் கண்டங்களைக் கடக்கும் நீண்ட தூர சரக்கு லாரிகள் வரை, போக்குவரத்து முறைகளின் பன்முகத்தன்மை வெடித்துள்ளது. இந்த சிக்கலானது ஒரு முக்கியமான மென்பொருள் பொறியியல் சவாலை முன்வைக்கிறது: இவ்வளவு பரந்த அளவிலான இயக்கம் விருப்பங்களை புத்திசாலித்தனமாக நிர்வகிக்கவும், வழிநடத்தவும் மற்றும் மேம்படுத்தவும் கூடிய அமைப்புகளை நாம் எவ்வாறு உருவாக்குவது? பதில் புத்திசாலித்தனமான வழிமுறைகளில் மட்டுமல்ல, ஒரு வலுவான மற்றும் நெகிழ்வான மென்பொருள் கட்டமைப்பிலும் உள்ளது. இங்குதான் TypeScript பிரகாசிக்கிறது.

இந்த விரிவான வழிகாட்டி மென்பொருள் கட்டிடக் கலைஞர்கள், பொறியாளர்கள் மற்றும் தளவாடங்கள், மொபிலிட்டி அஸ் எ சர்வீஸ் (MaaS) மற்றும் போக்குவரத்து துறைகளில் பணிபுரியும் தொழில்நுட்பத் தலைவர்களுக்கானது. TypeScript ஐப் பயன்படுத்தி வெவ்வேறு போக்குவரத்து முறைகளை மாதிரி செய்வதற்கான சக்திவாய்ந்த, வகை-பாதுகாப்பான அணுகுமுறையை நாங்கள் ஆராய்வோம் - அதை நாங்கள் 'இயக்கம் வகைகள்' என்று அழைப்போம். TypeScript இன் மேம்பட்ட வகை அமைப்பைப் பயன்படுத்துவதன் மூலம், சக்திவாய்ந்த தீர்வுகளை மட்டுமல்லாமல், அளவிடக்கூடிய, பராமரிக்கக்கூடிய மற்றும் பிழைக்கு கணிசமாக குறைவாக வாய்ப்புள்ள தீர்வுகளையும் உருவாக்க முடியும். அடிப்படை கருத்துக்களிலிருந்து நடைமுறைச் செயலாக்கத்திற்கு நகர்வோம், அடுத்த தலைமுறை போக்குவரத்து தளங்களை உருவாக்குவதற்கான ஒரு வரைபடத்தை உங்களுக்கு வழங்குவோம்.

சிக்கலான போக்குவரத்து தர்க்கத்திற்கு TypeScript ஐ ஏன் தேர்வு செய்ய வேண்டும்?

செயல்படுத்துவதற்குள் செல்வதற்கு முன், இந்த களத்திற்கு TypeScript ஏன் இவ்வளவு கட்டாயமான தேர்வாக இருக்கிறது என்பதைப் புரிந்துகொள்வது அவசியம். போக்குவரத்து தர்க்கம் விதிகள், கட்டுப்பாடுகள் மற்றும் எட்ஜ் கேஸ்களால் நிறைந்துள்ளது. ஒரு எளிய பிழை-சரக்கு ஏற்றுமதியை சைக்கிளுக்கு ஒதுக்குவது அல்லது குறைந்த பாலத்தின் கீழ் இரட்டை அடுக்கு பேருந்தை வழிநடத்துவது போன்றது-நிஜ உலகில் குறிப்பிடத்தக்க விளைவுகளை ஏற்படுத்தும். பாரம்பரிய JavaScript இல் இல்லாத பாதுகாப்பு வலையை TypeScript வழங்குகிறது.

• அளவிலான வகை பாதுகாப்பு: உற்பத்தியில் அல்ல, வளர்ச்சியின் போது பிழைகளைப் பிடிப்பதே முதன்மை நன்மை. 'வாகனம்', 'பாதசாரி' அல்லது 'பொது போக்குவரத்து வழி' என்றால் என்ன என்பதற்கான கடுமையான ஒப்பந்தங்களை வரையறுப்பதன் மூலம், குறியீடு மட்டத்தில் தர்க்கரீதியான செயல்பாடுகளைத் தடுக்கிறீர்கள். உதாரணமாக, நடக்கும் நபரைப் பிரதிநிதித்துவப்படுத்தும் இயக்கம் வகையின் மீது எரிபொருள்_திறன் பண்பை அணுகுவதிலிருந்து தொகுப்பி உங்களைத் தடுக்க முடியும்.
• மேம்படுத்தப்பட்ட டெவலப்பர் அனுபவம் மற்றும் ஒத்துழைப்பு: ஒரு பெரிய, உலகளவில் விநியோகிக்கப்பட்ட குழுவில், தெளிவான மற்றும் சுய-ஆவணப்படுத்தப்பட்ட குறியீடு அடிப்படை. TypeScript இன் இடைமுகங்கள் மற்றும் வகைகள் வாழும் ஆவணங்களாக செயல்படுகின்றன. TypeScript ஆதரவுடன் கூடிய எடிட்டர்கள் புத்திசாலித்தனமான தன்னியக்க நிரப்புதல் மற்றும் மறுசீரமைப்பு கருவிகளை வழங்குகின்றன, டெவலப்பர் உற்பத்தித்திறனை வியத்தகு முறையில் மேம்படுத்துகின்றன மற்றும் புதிய குழு உறுப்பினர்கள் சிக்கலான டொமைன் தர்க்கத்தைப் புரிந்துகொள்வதை எளிதாக்குகின்றன.
• அளவிடுதல் மற்றும் பராமரிப்பு: போக்குவரத்து அமைப்புகள் உருவாகின்றன. இன்று நீங்கள் கார்கள் மற்றும் வேன்களை நிர்வகிக்கலாம்; நாளை அது மின்சார ஸ்கூட்டர்கள், டெலிவரி டிரோன்கள் மற்றும் தன்னாட்சி பாட்களாக இருக்கலாம். நன்கு கட்டமைக்கப்பட்ட TypeScript பயன்பாடு புதிய இயக்கம் வகைகளை நம்பிக்கையுடன் சேர்க்க உங்களை அனுமதிக்கிறது. புதிய வகையைக் கையாள புதுப்பிக்கப்பட வேண்டிய அமைப்பின் ஒவ்வொரு பகுதியையும் சுட்டிக்காட்டி, தொகுப்பி உங்கள் வழிகாட்டியாக மாறுகிறது. ஒரு உற்பத்தி பிழை மூலம் மறக்கப்பட்ட `if-else` தொகுதியைக் கண்டுபிடிப்பதை விட இது மிகவும் சிறந்தது.
• சிக்கலான வணிக விதிகளை மாதிரி செய்தல்: போக்குவரத்து என்பது வேகம் மற்றும் தூரம் பற்றியது மட்டுமல்ல. இது வாகன பரிமாணங்கள், எடை வரம்புகள், சாலை கட்டுப்பாடுகள், டிரைவர் நேரம், சுங்க கட்டணம் மற்றும் சுற்றுச்சூழல் மண்டலங்கள் ஆகியவற்றை உள்ளடக்கியது. TypeScript இன் வகை அமைப்பு, குறிப்பாக பாகுபடுத்தப்பட்ட யூனியன்கள் மற்றும் இடைமுகங்கள் போன்ற அம்சங்கள், உங்கள் குறியீட்டில் நேரடியாக இந்த பலதரப்பட்ட விதிகளை மாதிரி செய்வதற்கு வெளிப்படையான மற்றும் நேர்த்தியான வழியை வழங்குகிறது.

முக்கிய கருத்துக்கள்: உலகளாவிய இயக்கம் வகையை வரையறுத்தல்

எங்கள் அமைப்பை உருவாக்குவதில் முதல் படி ஒரு பொதுவான மொழியை நிறுவுவதாகும். 'இயக்கம் வகை' என்றால் என்ன? இது எங்கள் போக்குவரத்து வலையமைப்பில் ஒரு பாதையை கடக்கக்கூடிய எந்தவொரு நிறுவனத்தின் சுருக்கமான பிரதிநிதித்துவம் ஆகும். இது ஒரு வாகனம் மட்டுமல்ல; இது ரூட்டிங், திட்டமிடல் மற்றும் மேம்பாட்டிற்கு தேவையான அனைத்து பண்புகளையும் கொண்ட ஒரு விரிவான சுயவிவரம்.

பெரும்பாலான, இல்லையெனில் அனைத்து, இயக்கம் வகைகளிலும் பொதுவான முக்கிய பண்புகளை வரையறுப்பதன் மூலம் தொடங்கலாம். இந்த பண்புகள் எங்கள் உலகளாவிய மாதிரியின் அடிப்படையை உருவாக்குகின்றன.

இயக்கம் வகையின் முக்கிய பண்புகள்

ஒரு வலுவான இயக்கம் வகை பின்வரும் தகவல் வகைகளை உள்ளடக்கியதாக இருக்க வேண்டும்:

• அடையாளம் மற்றும் வகைப்பாடு:
  • `id`: ஒரு தனித்துவமான சரம் அடையாளங்காட்டி (எ.கா., 'CARGO_VAN_XL', 'CITY_BICYCLE').
  • `வகை`: பரந்த வகைப்படுத்துதலுக்கான வகைப்படுத்தி (எ.கா., 'வாகனம்', 'மைக்ரோமொபிலிட்டி', 'பாதசாரி'), இது வகை-பாதுகாப்பான மாறுதலுக்கு முக்கியமானது.
  • `பெயர்`: மனிதனால் படிக்கக்கூடிய பெயர் (எ.கா., "கூடுதல் பெரிய சரக்கு வேன்").
• செயல்திறன் விவரக்குறிப்பு:
  • `வேக விவரக்குறிப்பு`: இது ஒரு எளிய சராசரி வேகமாக இருக்கலாம் (எ.கா., நடைபயிற்சிக்கு 5 கிமீ/மணி) அல்லது சாலை வகை, சாய்வு மற்றும் போக்குவரத்து நிலைமைகளைக் கருத்தில் கொள்ளும் சிக்கலான செயல்பாடு. வாகனங்களுக்கு, இது முடுக்கம் மற்றும் குறைப்பு மாதிரிகளை உள்ளடக்கியிருக்கலாம்.
  • `ஆற்றல் விவரக்குறிப்பு`: ஆற்றல் நுகர்வு வரையறுக்கிறது. இது எரிபொருள் திறன் (லிட்டர்/100 கிமீ அல்லது MPG), பேட்டரி திறன் மற்றும் நுகர்வு (kWh/கிமீ) அல்லது நடைபயிற்சி மற்றும் சைக்கிள் ஓட்டுதலுக்கான மனித கலோரி எரிப்பைக் கூட மாதிரியாகக் கொள்ளலாம்.
• உடல் கட்டுப்பாடுகள்:
  • `பரிமாணங்கள்`: மீட்டர்கள் போன்ற ஒரு நிலையான அலகு உள்ள `உயரம்`, `அகலம்` மற்றும் `நீளம்` ஆகியவற்றைக் கொண்ட ஒரு பொருள். பாலங்கள், சுரங்கங்கள் மற்றும் குறுகிய தெருக்களில் அனுமதி சரிபார்க்க முக்கியமானது.
  • `எடை`: கிலோகிராமில் `மொத்த எடை` மற்றும் `அச்சு எடை`க்கான ஒரு பொருள். எடை கட்டுப்பாடுகள் உள்ள பாலங்கள் மற்றும் சாலைகளுக்கு அவசியம்.
• செயல்பாட்டு மற்றும் சட்ட கட்டுப்பாடுகள்:
  • `அணுகல் அனுமதிகள்`: இது பயன்படுத்தக்கூடிய உள்கட்டமைப்பின் வகையை வரையறுக்கும் டேக்குகளின் வரிசை அல்லது தொகுப்பு (எ.கா., ['HIGHWAY', 'URBAN_ROAD', 'BIKE_LANE']).
  • `தடுக்கப்பட்ட அம்சங்கள்`: தவிர்க்க வேண்டிய விஷயங்களின் பட்டியல் (எ.கா., ['TOLL_ROADS', 'FERRIES', 'STAIRS']).
  • `சிறப்புப் பதவி`: அபாயகரமான பொருட்கள் அல்லது வெப்பநிலை கட்டுப்படுத்தப்பட்ட சரக்குகளுக்கு 'HAZMAT' போன்றவை, அவற்றின் சொந்த ரூட்டிங் விதிகளுடன் வருகின்றன.
• பொருளாதார மாதிரி:
  • `செலவு மாதிரி`: `கிலோ மீட்டருக்கு ஆகும் செலவு`, `மணிக்கு ஆகும் செலவு` (டிரைவர் சம்பளம் அல்லது வாகன தேய்மானம்) மற்றும் `நிலையான செலவு` (ஒரு பயணத்திற்கு) போன்ற செலவுகளை வரையறுக்கும் ஒரு அமைப்பு.
• சுற்றுச்சூழல் தாக்கம்:
  • `உமிழ்வு விவரக்குறிப்பு`: சுற்றுச்சூழலுக்கு உகந்த ரூட்டிங் மேம்பாடுகளை இயக்க, `co2GramsPerKilometer` போன்ற உமிழ்வுகளை விவரிக்கும் ஒரு பொருள்.

TypeScript இல் ஒரு நடைமுறை செயலாக்க மூலோபாயம்

இப்போது, இந்த கருத்துக்களை சுத்தமான, பராமரிக்கக்கூடிய TypeScript குறியீடாக மாற்றுவோம். இந்த மாதிரியான மாடலிங்கிற்கு TypeScript இன் மிகவும் சக்திவாய்ந்த அம்சங்களில் ஒன்றான இடைமுகங்கள், வகைகள் மற்றும் பாகுபடுத்தப்பட்ட யூனியன்களின் கலவையை நாங்கள் பயன்படுத்துவோம்.

படி 1: அடிப்படை இடைமுகங்களை வரையறுத்தல்

நாங்கள் முன்பு வரையறுத்த கட்டமைக்கப்பட்ட பண்புகளுக்கான இடைமுகங்களை உருவாக்குவதன் மூலம் தொடங்குவோம். உள்நாட்டில் ஒரு நிலையான அலகு முறையைப் பயன்படுத்துவது (மெட்ரிக் போன்றவை) மாற்றும் பிழைகளைத் தவிர்க்க ஒரு உலகளாவிய சிறந்த நடைமுறையாகும்.

உதாரணம்: அடிப்படை சொத்து இடைமுகங்கள்

// அனைத்து அலகுகளும் உள்நாட்டில் தரப்படுத்தப்பட்டுள்ளன, எ.கா., மீட்டர்கள், கிலோ, கிமீ/மணி

interface IDimensions {
  height: number;
  width: number;
  length: number;
}

interface IWeight {
  gross: number; // மொத்த எடை
  axleLoad?: number; // விருப்பமானது, குறிப்பிட்ட சாலை கட்டுப்பாடுகளுக்கு
}

interface ICostModel {
  perKilometer: number; // தூர அலகுக்கான செலவு
  perHour: number; // நேர அலகுக்கான செலவு
  fixed: number; // பயணத்திற்கான நிலையான செலவு
}

interface IEmissionsProfile {
  co2GramsPerKilometer: number;
}

அடுத்து, அனைத்து இயக்கம் வகைகளும் பகிரும் ஒரு அடிப்படை இடைமுகத்தை உருவாக்குகிறோம். பல பண்புகள் விருப்பமானவை என்பதை நினைவில் கொள்க, ஏனெனில் அவை ஒவ்வொரு வகைக்கும் பொருந்தாது (எ.கா., ஒரு பாதசாரிக்கு பரிமாணங்கள் அல்லது எரிபொருள் செலவு இல்லை).

உதாரணம்: மைய `IMobilityType` இடைமுகம்

interface IMobilityType {
  id: string;
  name: string;
  averageSpeedKph: number;
  accessPermissions: string[]; // எ.கா., ['PEDESTRIAN_PATH']
  prohibitedFeatures?: string[]; // எ.கா., ['HIGHWAY']
  costModel?: ICostModel;
  emissionsProfile?: IEmissionsProfile;
  dimensions?: IDimensions;
  weight?: IWeight;
}

படி 2: வகை-குறிப்பிட்ட தர்க்கத்திற்கான பாகுபடுத்தப்பட்ட யூனியன்களை மேம்படுத்துதல்

பாகுபடுத்தப்பட்ட யூனியன் என்பது ஒரு முறை, இதில் நீங்கள் ஒரு யூனியனில் உள்ள ஒவ்வொரு வகையிலும் ஒரு நேரடியான சொத்தைப் பயன்படுத்துகிறீர்கள் ('பாகுபடுத்தி') TypeScript நீங்கள் பணிபுரியும் குறிப்பிட்ட வகையைச் சுருக்க அனுமதிக்க. இது எங்கள் பயன்பாட்டு நிகழ்வுக்கு ஏற்றது. எங்கள் பாகுபடுத்தியாக செயல்பட `mobilityClass` சொத்தை சேர்ப்போம்.

வெவ்வேறு இயக்கத்தின் வகைகளுக்கான குறிப்பிட்ட இடைமுகங்களை வரையறுப்போம். ஒவ்வொன்றும் அடிப்படை `IMobilityType` ஐ நீட்டித்து அதன் சொந்த தனித்துவமான பண்புகளைச் சேர்க்கும், அத்துடன் அனைத்து முக்கியமான `mobilityClass` பாகுபடுத்தியையும் சேர்க்கும்.

உதாரணம்: குறிப்பிட்ட இயக்கம் இடைமுகங்களை வரையறுத்தல்

interface IPedestrianProfile extends IMobilityType {
  mobilityClass: 'PEDESTRIAN';
  avoidsTraffic: boolean; // பூங்காக்கள் வழியாக குறுக்குவழிகளைப் பயன்படுத்தலாம், போன்றவை.
}

interface IBicycleProfile extends IMobilityType {
  mobilityClass: 'BICYCLE';
  requiresBikeParking: boolean;
}

// மோட்டார் பொருத்தப்பட்ட வாகனங்களுக்கான மிகவும் சிக்கலான வகை
interface IVehicleProfile extends IMobilityType {
  mobilityClass: 'VEHICLE';
  fuelType: 'GASOLINE' | 'DIESEL' | 'ELECTRIC' | 'HYBRID';
  fuelCapacity?: number; // லிட்டர்கள் அல்லது kWh இல்
  // வாகனங்களுக்கான பரிமாணங்களையும் எடையையும் தேவை
  dimensions: IDimensions;
  weight: IWeight;
}

interface IPublicTransitProfile extends IMobilityType {
  mobilityClass: 'PUBLIC_TRANSIT';
  agencyName: string; // எ.கா., "TfL", "MTA"
  mode: 'BUS' | 'TRAIN' | 'SUBWAY' | 'TRAM';
}

இப்போது, அவற்றை ஒரு யூனியன் வகையாக இணைக்கிறோம். இந்த `MobilityProfile` வகை எங்கள் அமைப்பின் மூலக்கல்லாகும். ரூட்டிங் அல்லது மேம்பாட்டைச் செய்யும் எந்தவொரு செயல்பாடும் இந்த வகையின் வாதத்தை ஏற்கும்.

உதாரணம்: இறுதி யூனியன் வகை

type MobilityProfile = IPedestrianProfile | IBicycleProfile | IVehicleProfile | IPublicTransitProfile;

படி 3: உறுதியான இயக்கம் வகை நிகழ்வுகளை உருவாக்குதல்

எங்கள் வகைகள் மற்றும் இடைமுகங்கள் வரையறுக்கப்பட்டு, உறுதியான இயக்கம் சுயவிவரங்களின் நூலகத்தை உருவாக்கலாம். இவை எங்கள் வரையறுக்கப்பட்ட வடிவங்களுக்கு இணங்கக்கூடிய சாதாரணமான பொருள்கள். இந்த நூலகத்தை தரவுத்தளத்தில் அல்லது உள்ளமைவு கோப்பில் சேமித்து இயக்க நேரத்தில் ஏற்றலாம்.

உதாரணம்: உறுதியான நிகழ்வுகள்

const WALKING_PROFILE: IPedestrianProfile = {
  id: 'pedestrian_standard',
  name: 'நடப்பது',
  mobilityClass: 'PEDESTRIAN',
  averageSpeedKph: 5,
  accessPermissions: ['PEDESTRIAN_PATH', 'SIDEWALK', 'PARK_TRAIL'],
  prohibitedFeatures: ['HIGHWAY', 'TUNNEL_VEHICLE_ONLY'],
  avoidsTraffic: true,
  emissionsProfile: { co2GramsPerKilometer: 0 },
};

const CARGO_VAN_PROFILE: IVehicleProfile = {
  id: 'van_cargo_large_diesel',
  name: 'பெரிய டீசல் சரக்கு வேன்',
  mobilityClass: 'VEHICLE',
  averageSpeedKph: 60,
  accessPermissions: ['HIGHWAY', 'URBAN_ROAD'],
  fuelType: 'DIESEL',
  dimensions: { height: 2.7, width: 2.2, length: 6.0 },
  weight: { gross: 3500 },
  costModel: { perKilometer: 0.3, perHour: 25, fixed: 10 },
  emissionsProfile: { co2GramsPerKilometer: 250 },
};

ஒரு ரூட்டிங் எஞ்சினில் இயக்கம் வகைகளைப் பயன்படுத்துதல்

இந்த கட்டமைப்பின் உண்மையான சக்தி, எங்கள் மைய பயன்பாட்டு தர்க்கத்தில், அதாவது ரூட்டிங் எஞ்சின் போன்ற இடங்களில் இந்த வகைப்படுத்தப்பட்ட சுயவிவரங்களைப் பயன்படுத்தும்போது தெளிவாகிறது. பாகுபடுத்தப்பட்ட யூனியன் வெவ்வேறு இயக்கம் விதிகளுக்கு சுத்தமான, முழுமையான மற்றும் வகை-பாதுகாப்பான குறியீட்டை எழுத அனுமதிக்கிறது.

ஒரு இயக்கம் வகை ஒரு குறிப்பிட்ட சாலை வலையமைப்பின் பகுதியை கடக்க முடியுமா என்பதை தீர்மானிக்க வேண்டிய ஒரு செயல்பாடு எங்களிடம் உள்ளது என்று கற்பனை செய்து பாருங்கள் (வரைபடக் கோட்பாட்டின் அடிப்படையில் 'எட்ஜ்'). இந்த எட்ஜ் `maxHeight`, `maxWeight`, `allowedAccessTags` போன்ற பண்புகளைக் கொண்டுள்ளது.

முழுமையான `switch` கூற்றுகளுடன் வகை-பாதுகாப்பான தர்க்கம்

எங்கள் `MobilityProfile` வகையைப் பயன்படுத்தும் ஒரு செயல்பாடு `mobilityClass` பண்பில் `switch` கூற்றைப் பயன்படுத்தலாம். TypeScript இதைப் புரிந்துகொள்கிறது மற்றும் ஒவ்வொரு `case` தொகுதியிலும் `சுயவிவரத்தின்` வகையை புத்திசாலித்தனமாகச் சுருக்கிக் கொள்ளும். இதன் பொருள் `'VEHICLE'` வழக்கில், கம்பைலர் புகார் செய்யாமல் `profile.dimensions.height` ஐ பாதுகாப்பாக அணுகலாம், ஏனெனில் அது `IVehicleProfile` ஆக மட்டுமே இருக்க முடியும் என்று தெரியும்.

மேலும், உங்கள் tsconfig இல் `"strictNullChecks": true` இயக்கப்பட்டிருந்தால், உங்கள் `switch` கூற்று முழுமையானது என்பதை TypeScript தொகுப்பி உறுதி செய்யும். நீங்கள் `MobilityProfile` யூனியனில் ஒரு புதிய வகையைச் சேர்த்தால் (எ.கா., `IDroneProfile`) ஆனால் அதற்கான `case` ஐச் சேர்க்க மறந்துவிட்டால், தொகுப்பி ஒரு பிழையை உருவாக்கும். இது பராமரிப்புக்கு நம்பமுடியாத சக்திவாய்ந்த அம்சமாகும்.

உதாரணம்: வகை-பாதுகாப்பான அணுகலைச் சரிபார்க்கும் செயல்பாடு

// RoadSegment என்பது சாலையின் ஒரு பகுதிக்கான வரையறுக்கப்பட்ட வகை என்று வைத்துக் கொள்ளுங்கள்
interface RoadSegment {
  id: number;
  allowedAccess: string[]; // எ.கா., ['HIGHWAY', 'VEHICLE']
  maxHeight?: number;
  maxWeight?: number;
}

function canTraverse(profile: MobilityProfile, segment: RoadSegment): boolean {
  // அடிப்படைச் சரிபார்ப்பு: இந்த பொதுவான வகை அணுகலை இந்த பிரிவு அனுமதிக்கிறதா?
  const hasAccessPermission = profile.accessPermissions.some(perm => segment.allowedAccess.includes(perm));
  if (!hasAccessPermission) {
    return false;
  }

  // இப்போது, குறிப்பிட்ட சோதனைகளுக்கு பாகுபடுத்தப்பட்ட யூனியனைப் பயன்படுத்தவும்
  switch (profile.mobilityClass) {
    case 'PEDESTRIAN':
      // பாதசாரிகளுக்கு சில உடல் கட்டுப்பாடுகள் உள்ளன
      return true;

    case 'BICYCLE':
      // சைக்கிள்களுக்கு சில குறிப்பிட்ட கட்டுப்பாடுகள் இருக்கலாம், ஆனால் இங்கு எளிமையானவை
      return true;

    case 'VEHICLE':
      // TypeScript க்கு `சுயவிவரம்` IVehicleProfile என்பது தெரியும்!
      // பரிமாணங்களையும் எடையையும் பாதுகாப்பாக அணுகலாம்.
      if (segment.maxHeight && profile.dimensions.height > segment.maxHeight) {
        return false; // இந்த பாலம்/சுரங்கத்திற்கு மிகவும் உயரமானது
      }
      if (segment.maxWeight && profile.weight.gross > segment.maxWeight) {
        return false; // இந்த பாலத்திற்கு மிகவும் கனமானது
      }
      return true;

    case 'PUBLIC_TRANSIT':
      // பொது போக்குவரத்து நிலையான வழிகளைப் பின்பற்றுகிறது, எனவே இந்தச் சரிபார்ப்பு வித்தியாசமாக இருக்கலாம்
      // இப்போது, அது அடிப்படை அணுகலைப் பெற்றிருந்தால் செல்லுபடியாகும் என்று கருதுகிறோம்
      return true;

    default:
      // இந்த இயல்புநிலை வழக்கு முழுமையைக் கையாளுகிறது.
      const _exhaustiveCheck: never = profile;
      return _exhaustiveCheck;
  }
}

உலகளாவிய கருத்தில் மற்றும் விரிவாக்கத்தன்மை

உலகளாவிய பயன்பாட்டிற்காக வடிவமைக்கப்பட்ட ஒரு அமைப்பு மாற்றியமைக்கக்கூடியதாக இருக்க வேண்டும். விதிமுறைகள், அலகுகள் மற்றும் கிடைக்கக்கூடிய போக்குவரத்து முறைகள் கண்டங்கள், நாடுகள் மற்றும் நகரங்களுக்கு இடையே வியத்தகு முறையில் வேறுபடுகின்றன. இந்த சிக்கலை கையாள எங்கள் கட்டமைப்பு மிகவும் பொருத்தமானது.

மண்டல வேறுபாடுகளை கையாளுதல்

• அளவீட்டு அலகுகள்: உலகளாவிய அமைப்புகளில் பிழையின் பொதுவான ஆதாரம் மெட்ரிக் (கிலோமீட்டர்கள், கிலோகிராம்கள்) மற்றும் ஏகாதிபத்திய (மைல்கள், பவுண்டுகள்) அலகுகளுக்கு இடையிலான கலவையாகும். சிறந்த பயிற்சி: உங்கள் முழு பின்புல அமைப்பையும் ஒரு அலகு அமைப்பில் தரப்படுத்தவும் (மெட்ரிக் அறிவியல் மற்றும் உலகளாவிய தரநிலை). `MobilityProfile` மெட்ரிக் மதிப்புகளை மட்டுமே கொண்டிருக்க வேண்டும். ஏகாதிபத்திய அலகுகளுக்கான அனைத்து மாற்றங்களும் பயனரின் அமைவிடத்தின் அடிப்படையில் விளக்கக்காட்சி அடுக்கில் (API பதில் அல்லது முன் முடிவு UI) நடக்க வேண்டும்.
• உள்ளூர் விதிமுறைகள்: மத்திய லண்டனில் அதன் அல்ட்ரா லோ எமிஷன் ஜோன் (ULEZ) உடன் சரக்கு வேனின் ரூட்டிங், கிராமப்புற டெக்சாஸில் அதன் ரூட்டிங்கிலிருந்து மிகவும் வேறுபட்டது. கட்டுப்பாடுகளை மாறும் வகையில் செய்வதன் மூலம் இதை கையாளலாம். `accessPermissions` ஐ ஹார்ட்கோட் செய்வதற்குப் பதிலாக, ரூட்டிங் கோரிக்கை ஒரு புவியியல் சூழலை உள்ளடக்கியிருக்கலாம் (எ.கா., `context: 'london_city_center'`). உங்கள் எஞ்சின் அந்த சூழலுக்கு குறிப்பிட்ட விதிகளின் தொகுப்பைப் பயன்படுத்தும், அதாவது வாகனத்தின் `fuelType` அல்லது `emissionsProfile` ஐ ULEZ தேவைகளுக்கு எதிராக சரிபார்க்கும்.
• மாறும் தரவு: ஒரு அடிப்படை சுயவிவரத்தை நிகழ்நேர தரவுகளுடன் இணைத்து 'நீரேற்றப்பட்ட' சுயவிவரங்களை உருவாக்கலாம். உதாரணமாக, அடிப்படை `CAR_PROFILE` ஒரு குறிப்பிட்ட நேரத்தில் ஒரு குறிப்பிட்ட பாதையில் மாறும் `வேக விவரக்குறிப்பை` உருவாக்க நேரடி போக்குவரத்து தரவுடன் இணைக்கப்படலாம்.

புதிய இயக்கம் வகைகளுடன் மாதிரியை நீட்டித்தல்

உங்கள் நிறுவனம் டெலிவரி டிரோன் சேவையைத் தொடங்க முடிவு செய்தால் என்ன நடக்கும்? இந்த கட்டமைப்பின் மூலம், செயல்முறை கட்டமைக்கப்பட்டுள்ளது மற்றும் பாதுகாப்பானது:

1. இடைமுகத்தை வரையறுக்கவும்: `IMobilityType` ஐ நீட்டிக்கும் ஒரு புதிய `IDroneProfile` இடைமுகத்தை உருவாக்கவும் மற்றும் `maxFlightAltitude`, `batteryLifeMinutes` மற்றும் `payloadCapacityKg` போன்ற டிரோன்-குறிப்பிட்ட பண்புகளை உள்ளடக்கவும். பாகுபடுத்தியை மறந்துவிடாதீர்கள்: `mobilityClass: 'DRONE';`
2. யூனியனைப் புதுப்பிக்கவும்: `IDroneProfile` ஐ `MobilityProfile` யூனியன் வகைக்குச் சேர்க்கவும்: `type MobilityProfile = ... | IDroneProfile;`
3. தொகுப்பி பிழைகளைப் பின்பற்றவும்: இது மந்திரப்படி. TypeScript தொகுப்பி இப்போது முழுமையானதாக இல்லாத ஒவ்வொரு `switch` கூற்றிலும் பிழைகளை உருவாக்கும். இது `canTraverse` போன்ற ஒவ்வொரு செயல்பாட்டையும் உங்களுக்கு சுட்டிக்காட்டி 'DRONE' வழக்குக்கான தர்க்கத்தை செயல்படுத்த உங்களை கட்டாயப்படுத்தும். இந்த முறையான செயல்முறை எந்த முக்கியமான தர்க்கத்தையும் தவறவிடாமல் இருப்பதை உறுதி செய்கிறது, புதிய அம்சங்களை அறிமுகப்படுத்தும்போது பிழைகளின் அபாயத்தை வியத்தகு முறையில் குறைக்கிறது.
4. தர்க்கத்தை செயல்படுத்தவும்: உங்கள் ரூட்டிங் எஞ்சினில், டிரோன்களுக்கான தர்க்கத்தைச் சேர்க்கவும். இது தரைவழி வாகனங்களிலிருந்து முற்றிலும் மாறுபட்டதாக இருக்கும். இது சாலை வலையமைப்பு பண்புகளுக்கு பதிலாக பறக்க தடைசெய்யப்பட்ட மண்டலங்கள், வானிலை நிலைகள் (காற்று வேகம்) மற்றும் தரையிறங்கும் பேட் கிடைக்கும் தன்மை ஆகியவற்றைச் சரிபார்ப்பதை உள்ளடக்கியிருக்கலாம்.

முடிவு: எதிர்கால இயக்கத்திற்கான அடித்தளத்தை உருவாக்குதல்

போக்குவரத்தை மேம்படுத்துவது நவீன மென்பொருள் பொறியியலில் மிகவும் சிக்கலான மற்றும் தாக்கத்தை ஏற்படுத்தும் சவால்களில் ஒன்றாகும். நாம் உருவாக்கும் அமைப்புகள் துல்லியமானதாகவும், நம்பகமானதாகவும் இருக்க வேண்டும் மற்றும் இயக்க விருப்பங்களின் விரைவாக வளர்ந்து வரும் நிலப்பரப்புக்கு ஏற்றதாக இருக்க வேண்டும். TypeScript இன் வலுவான தட்டச்சு, குறிப்பாக பாகுபடுத்தப்பட்ட யூனியன்கள் போன்ற வடிவங்களை ஏற்றுக்கொள்வதன் மூலம், இந்த சிக்கலுக்கு ஒரு உறுதியான அடித்தளத்தை உருவாக்க முடியும்.

நாங்கள் கோடிட்டுக் காட்டிய இயக்கம் வகை செயலாக்கம் குறியீடு கட்டமைப்பை விட அதிகமாக வழங்குகிறது; இது சிக்கலைப் பற்றி சிந்திப்பதற்கான ஒரு தெளிவான, பராமரிக்கக்கூடிய மற்றும் அளவிடக்கூடிய வழியை வழங்குகிறது. இது சுருக்கமான வணிக விதிகளை உறுதியான, வகை-பாதுகாப்பான குறியீடாக மாற்றுகிறது, இது பிழைகளைத் தடுக்கிறது, டெவலப்பர் உற்பத்தித்திறனை மேம்படுத்துகிறது மற்றும் உங்கள் தளம் நம்பிக்கையுடன் வளர அனுமதிக்கிறது. நீங்கள் ஒரு உலகளாவிய தளவாட நிறுவனத்திற்கான ரூட்டிங் எஞ்சினை உருவாக்குகிறீர்களா, ஒரு பெரிய நகரத்திற்கான பல-முறை பயணத் திட்டமிடுபவர் அல்லது ஒரு தன்னாட்சி கடற்படை மேலாண்மை அமைப்பு, நன்கு வடிவமைக்கப்பட்ட வகை அமைப்பு ஒரு ஆடம்பரம் அல்ல-இது வெற்றிக்கு தேவையான வரைபடம்.